{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ridge Regression\n",
    "\n",
    "#### Author: Yiran Jing\n",
    "\n",
    "#### Date: Feb 2020\n",
    "\n",
    "\n",
    "## Contents:\n",
    "1. Model selection\n",
    "   - Linear regression\n",
    "   - Ridge regression\n",
    "   - Lasso regression\n",
    "   \n",
    "Lasso performs best using `Days`, `suspected`, `confirmed_lag1` as regressors\n",
    "\n",
    "2. Ridge Residual Dignostic\n",
    "\n",
    "3. Model prediction\n",
    "\n",
    "## Summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import operator\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import pandas\n",
    "import datetime\n",
    "import seaborn as sns\n",
    "import matplotlib.dates as mdates\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "# Import models from scikit learn module\n",
    "from sklearn.linear_model import Ridge, RidgeCV, ElasticNet, LassoCV, LassoLarsCV, LinearRegression, ElasticNetCV\n",
    "from helper_fun_model import *\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020-02-16 14:14:52Update records successfully to ../data/DXY_Chinese.csv\n",
      "Save area daily dataset (English) into ../data/DXYArea.csv\n",
      "CPU times: user 374 ms, sys: 109 ms, total: 483 ms\n",
      "Wall time: 28.2 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "## Update data from DXY\n",
    "! cd ../data_processing && python DXY_AreaData_query.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Load data \n",
    "df = pd.read_csv(\"../data/DXYArea.csv\")\n",
    "\"\"\"\n",
    "Data Cleaning \n",
    "\"\"\"\n",
    "df['date'] = pd.to_datetime(df['date'])\n",
    "df = df[df['date'] != df['date'].max()] # remove todays' records (since it can be incompleted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df[df['date']>'2020-01-14']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Case 1: Overall China"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "china_df = get_China_total(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#features_to_engineer = ['confirmed', 'suspected']\n",
    "features_to_engineer = ['confirmed'] # only calculate lag 1 for predictor, not regressor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "china_df = feature_engineering(china_df, features_to_engineer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>date</th>\n",
       "      <th>country</th>\n",
       "      <th>countryCode</th>\n",
       "      <th>province</th>\n",
       "      <th>city</th>\n",
       "      <th>confirmed</th>\n",
       "      <th>suspected</th>\n",
       "      <th>cured</th>\n",
       "      <th>dead</th>\n",
       "      <th>Days</th>\n",
       "      <th>net_confirmed</th>\n",
       "      <th>confirmed_lag1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>7126</th>\n",
       "      <td>2020-02-14</td>\n",
       "      <td>中国</td>\n",
       "      <td>CN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>66575</td>\n",
       "      <td>8969</td>\n",
       "      <td>8101</td>\n",
       "      <td>1524</td>\n",
       "      <td>68</td>\n",
       "      <td>56950</td>\n",
       "      <td>63932.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7471</th>\n",
       "      <td>2020-02-15</td>\n",
       "      <td>中国</td>\n",
       "      <td>CN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>68584</td>\n",
       "      <td>8229</td>\n",
       "      <td>9425</td>\n",
       "      <td>1666</td>\n",
       "      <td>69</td>\n",
       "      <td>57493</td>\n",
       "      <td>66575.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           date country countryCode province city  confirmed  suspected  \\\n",
       "7126 2020-02-14      中国          CN      NaN  NaN      66575       8969   \n",
       "7471 2020-02-15      中国          CN      NaN  NaN      68584       8229   \n",
       "\n",
       "      cured  dead  Days  net_confirmed  confirmed_lag1  \n",
       "7126   8101  1524    68          56950         63932.0  \n",
       "7471   9425  1666    69          57493         66575.0  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "china_df.tail(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train dataset: data before 2020-02-10 00:00:00 \n",
      "Test dataset: the last 5 days\n"
     ]
    }
   ],
   "source": [
    "Train, Test = split_train_test_by_date(china_df, 5) \n",
    "\n",
    "regressors = ['Days', 'suspected'] # other variables we want to apply into model\n",
    "#regressors = ['Days']\n",
    "\n",
    "\n",
    "X_train = Train.loc[:,regressors + [x+'_lag1' for x in features_to_engineer]]\n",
    "y_train = Train['confirmed']\n",
    "X_test =  Test.loc[:,regressors + [x+'_lag1' for x in features_to_engineer]]\n",
    "y_test = Test['confirmed']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Days', 'suspected', 'confirmed_lag1'], dtype='object')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.columns # regressor within model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use StandardScaler to transform numerical data \n",
    "# Note: truning sc based on X_train\n",
    "sc = StandardScaler().fit(X_train)\n",
    "X_train_sc = sc.transform(X_train)\n",
    "#X_validate_numerical_sc = sc.transform(X_validate_numerical)\n",
    "X_test_sc = sc.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.66666667, -1.0496374 , -0.8251839 ],\n",
       "       [-1.53333333, -1.0496374 , -0.82174408],\n",
       "       [-1.4       , -1.0496374 , -0.82140848]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_sc[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear Regression MAPE on Validation set : 0.056702261703221964\n",
      "Linear Regression MAE on Validation set : 3457.6388138600546\n",
      "Linear Regression R2 on Validation set : 0.7091787851793272\n"
     ]
    }
   ],
   "source": [
    "# Fit the linear regression\n",
    "linear = LinearRegression()\n",
    "linear.fit(X_train_sc, y_train)\n",
    "\n",
    "# # Find the validation score\n",
    "get_validation_score(linear, X_test_sc, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LASSO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "basic alpha : 60.69496136740685\n"
     ]
    }
   ],
   "source": [
    "# Find from default hyperparameters \n",
    "lasso = LassoCV(cv=10)\n",
    "lasso.fit(X_train_sc, y_train)\n",
    "alpha = lasso.alpha_\n",
    "print(\"basic alpha :\", alpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Try again for more precision with alphas centered around 60.69496136740685\n",
      "Best alpha : 54.625465230666165\n"
     ]
    }
   ],
   "source": [
    "# Find from more refined list\n",
    "print(\"Try again for more precision with alphas centered around \" + str(alpha))\n",
    "lasso = LassoCV(alphas = [alpha * .6, alpha * .65, alpha * .7, alpha * .75, alpha * .8, \n",
    "                          alpha * .85, alpha * .9, alpha * .95, alpha, alpha * 1.05, \n",
    "                          alpha * 1.1, alpha * 1.15, alpha * 1.25, alpha * 1.3, alpha * 1.35, \n",
    "                          alpha * 1.4], \n",
    "                max_iter = 50000, cv = 5)\n",
    "lasso.fit(X_train_sc, y_train)\n",
    "alpha = lasso.alpha_\n",
    "print(\"Best alpha :\", alpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear Regression MAPE on Validation set : 0.058677786581701134\n",
      "Linear Regression MAE on Validation set : 3579.3900118362144\n",
      "Linear Regression R2 on Validation set : 0.6995322154670371\n"
     ]
    }
   ],
   "source": [
    "# # Find the validation score\n",
    "get_validation_score(lasso, X_test_sc, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ridge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "basic alpha : 0.1\n"
     ]
    }
   ],
   "source": [
    "# Find from default hyperparameters \n",
    "ridge = RidgeCV(cv=5)\n",
    "ridge.fit(X_train_sc, y_train)\n",
    "alpha = ridge.alpha_\n",
    "print(\"basic alpha :\", alpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Try again for more precision with alphas centered around 0.1\n",
      "Best alpha : 0.06\n"
     ]
    }
   ],
   "source": [
    "# Find from more refined list\n",
    "print(\"Try again for more precision with alphas centered around \" + str(alpha))\n",
    "ridge = RidgeCV(alphas = [alpha * .6, alpha * .65, alpha * .7, alpha * .75, alpha * .8, \n",
    "                          alpha * .85, alpha * .9, alpha * .95, alpha, alpha * 1.05, \n",
    "                          alpha * 1.1, alpha * 1.15, alpha * 1.25, alpha * 1.3, alpha * 1.35, \n",
    "                          alpha * 1.4], cv = 5)\n",
    "ridge.fit(X_train_sc, y_train)\n",
    "alpha = ridge.alpha_\n",
    "print(\"Best alpha :\", alpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear Regression MAPE on Validation set : 0.06345581028984114\n",
      "Linear Regression MAE on Validation set : 3870.098410464074\n",
      "Linear Regression R2 on Validation set : 0.67935080063222\n"
     ]
    }
   ],
   "source": [
    "# # Find the validation score\n",
    "get_validation_score(ridge, X_test_sc, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save prediction result to CSV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_index = X_train.index\n",
    "test_index = X_test.index\n",
    "\n",
    "# Create dataframe\n",
    "X_train = pd.DataFrame(X_train_sc, columns=X_train.columns, index=train_index)\n",
    "#X_validate_numerical_sc = pd.DataFrame(X_validate_numerical_sc, columns=numerical, index=validate_index)\n",
    "X_test = pd.DataFrame(X_test_sc, columns=X_train.columns, index=test_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the predictions \n",
    "predictions_ridge = np.squeeze(ridge.predict(X_test))\n",
    "\n",
    "# Calculate the residuals\n",
    "residuals_ridge = np.squeeze(y_test) - predictions_ridge\n",
    "\n",
    "# Create dataframe\n",
    "d = {'y_test': np.squeeze(y_test), 'predictions': predictions_ridge, 'residuals_ridge': residuals_ridge}\n",
    "df_residuals_ridge = pd.DataFrame(data=d, index=test_index)\n",
    "\n",
    "# Left join the period\n",
    "df_residuals_ridge['date'] = Test['date']\n",
    "\n",
    "df_residuals_ridge.shape\n",
    "\n",
    "# Write to a csv file\n",
    "df_residuals_ridge.to_csv('prediction/residuals_ridge_test_0216.csv', index_label='test_index')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the predictions \n",
    "predictions_ridge = np.squeeze(ridge.predict(X_train))\n",
    "\n",
    "# Calculate the residuals\n",
    "residuals_ridge = np.squeeze(y_train) - predictions_ridge\n",
    "\n",
    "# Create dataframe\n",
    "d = {'y_train': np.squeeze(y_train), 'predictions': predictions_ridge, 'residuals_ridge': residuals_ridge}\n",
    "df_residuals_ridge = pd.DataFrame(data=d, index=train_index)\n",
    "\n",
    "# Left join the period\n",
    "df_residuals_ridge['date'] = Train['date']\n",
    "\n",
    "# Write to a csv file\n",
    "df_residuals_ridge.to_csv('prediction/residuals_ridge_train_0216.csv', index_label='train_index')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>y_train</th>\n",
       "      <th>predictions</th>\n",
       "      <th>residuals_ridge</th>\n",
       "      <th>date</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>135</th>\n",
       "      <td>41</td>\n",
       "      <td>-154.250696</td>\n",
       "      <td>195.250696</td>\n",
       "      <td>2020-01-15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>138</th>\n",
       "      <td>45</td>\n",
       "      <td>-60.924337</td>\n",
       "      <td>105.924337</td>\n",
       "      <td>2020-01-16</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     y_train  predictions  residuals_ridge       date\n",
       "135       41  -154.250696       195.250696 2020-01-15\n",
       "138       45   -60.924337       105.924337 2020-01-16"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_residuals_ridge.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ridge Residual Dignostic\n",
    "\n",
    "Since ridge is the optimal model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.JointGrid at 0x1200122e8>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.jointplot(\"y_train\", \"residuals_ridge\", data=df_residuals_ridge, kind=\"reg\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ridge model prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "ridge_res_train = pd.read_csv('prediction/residuals_ridge_train_0216.csv')\n",
    "del ridge_res_train['train_index']\n",
    "ridge_res_test = pd.read_csv('prediction/residuals_ridge_test_0216.csv')\n",
    "del ridge_res_test['test_index']\n",
    "\n",
    "ridge_res_test.Timestamp = pd.to_datetime(ridge_res_test.date,format='%Y-%m-%d %H:%M') \n",
    "ridge_res_test.index = ridge_res_test.Timestamp\n",
    "ridge_res_test = ridge_res_test.sort_index()\n",
    "\n",
    "ridge_res_train.Timestamp = pd.to_datetime(ridge_res_train.date,format='%Y-%m-%d %H:%M') \n",
    "ridge_res_train.index = ridge_res_train.Timestamp\n",
    "ridge_res_train = ridge_res_train.sort_index()\n",
    "\n",
    "ridge_all = pd.concat([ridge_res_train,ridge_res_test])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1224x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plotting data\n",
    "ridge_res_train['predictions'].plot(figsize=(17,6), title= 'Baseline: Confirmed Cases Forecast by Ridge regression (China total)', fontsize=10,\n",
    "                                        label= 'Fitted value',linewidth=1, color = 'grey')\n",
    "ridge_res_train['y_train'].plot(figsize=(17,6),label= 'Observation',linewidth=1, color = 'steelblue')\n",
    "ridge_res_test['y_test'].plot(figsize=(17,6), label= 'Observation', linewidth=1, color = 'steelblue')\n",
    "\n",
    "ridge_res_test['predictions'].plot(figsize=(17,6), label= 'Ridge forecasting', color = 'tomato',linewidth=1)\n",
    "plt.ylabel('Confirmed cases')\n",
    "plt.xlabel('')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
